% Copyright (c) 2013-2014, Cornell University
% All rights reserved.
%
% Redistribution and use in source and binary forms, with or without
% modification, are permitted provided that the following conditions are met:
%
%     * Redistributions of source code must retain the above copyright notice,
%       this list of conditions and the following disclaimer.
%     * Redistributions in binary form must reproduce the above copyright
%       notice, this list of conditions and the following disclaimer in the
%       documentation and/or other materials provided with the distribution.
%     * Neither the name of HyperDex nor the names of its contributors may be
%       used to endorse or promote products derived from this software without
%       specific prior written permission.
%
% THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
% AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
% IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
% DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
% FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
% DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
% SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
% CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
% OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
% OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

% This LaTeX file is generated by bindings/c.py

%%%%%%%%%%%%%%%%%%%% get %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{get}}
\label{api:c:get}
\index{get!C API}
\input{\topdir/client/fragments/get}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_get(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        enum hyperdex_client_returncode* status,
        const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{const struct hyperdex\_client\_attribute** attrs, size\_t* attrs\_sz}\\
\input{\topdir/c/client/fragments/out_asynccall_attributes}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% get_partial %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{get\_partial}}
\label{api:c:get_partial}
\index{get\_partial!C API}
\input{\topdir/client/fragments/get_partial}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_get_partial(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const char** attrnames, size_t attrnames_sz,
        enum hyperdex_client_returncode* status,
        const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const char** attrnames, size\_t attrnames\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributenames}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{const struct hyperdex\_client\_attribute** attrs, size\_t* attrs\_sz}\\
\input{\topdir/c/client/fragments/out_asynccall_attributes}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% put %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{put}}
\label{api:c:put}
\index{put!C API}
\input{\topdir/client/fragments/put}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_put(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_put %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_put}}
\label{api:c:cond_put}
\index{cond\_put!C API}
\input{\topdir/client/fragments/cond_put}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_put(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_put_or_create %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_put\_or\_create}}
\label{api:c:cond_put_or_create}
\index{cond\_put\_or\_create!C API}
\input{\topdir/client/fragments/cond_put_or_create}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_put_or_create(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_put %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_put}}
\label{api:c:group_put}
\index{group\_put!C API}
\input{\topdir/client/fragments/group_put}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_put(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% put_if_not_exist %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{put\_if\_not\_exist}}
\label{api:c:put_if_not_exist}
\index{put\_if\_not\_exist!C API}
\input{\topdir/client/fragments/put_if_not_exist}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_put_if_not_exist(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% del %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{del}}
\label{api:c:del}
\index{del!C API}
\input{\topdir/client/fragments/del}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_del(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_del %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_del}}
\label{api:c:cond_del}
\index{cond\_del!C API}
\input{\topdir/client/fragments/cond_del}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_del(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_del %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_del}}
\label{api:c:group_del}
\index{group\_del!C API}
\input{\topdir/client/fragments/group_del}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_del(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_add}}
\label{api:c:atomic_add}
\index{atomic\_add!C API}
\input{\topdir/client/fragments/atomic_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_add}}
\label{api:c:cond_atomic_add}
\index{cond\_atomic\_add!C API}
\input{\topdir/client/fragments/cond_atomic_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_add}}
\label{api:c:group_atomic_add}
\index{group\_atomic\_add!C API}
\input{\topdir/client/fragments/group_atomic_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_add(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_sub}}
\label{api:c:atomic_sub}
\index{atomic\_sub!C API}
\input{\topdir/client/fragments/atomic_sub}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_sub(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_sub}}
\label{api:c:cond_atomic_sub}
\index{cond\_atomic\_sub!C API}
\input{\topdir/client/fragments/cond_atomic_sub}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_sub(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_sub}}
\label{api:c:group_atomic_sub}
\index{group\_atomic\_sub!C API}
\input{\topdir/client/fragments/group_atomic_sub}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_sub(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_mul}}
\label{api:c:atomic_mul}
\index{atomic\_mul!C API}
\input{\topdir/client/fragments/atomic_mul}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_mul(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_mul}}
\label{api:c:cond_atomic_mul}
\index{cond\_atomic\_mul!C API}
\input{\topdir/client/fragments/cond_atomic_mul}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_mul(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_mul}}
\label{api:c:group_atomic_mul}
\index{group\_atomic\_mul!C API}
\input{\topdir/client/fragments/group_atomic_mul}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_mul(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_div}}
\label{api:c:atomic_div}
\index{atomic\_div!C API}
\input{\topdir/client/fragments/atomic_div}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_div(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_div}}
\label{api:c:cond_atomic_div}
\index{cond\_atomic\_div!C API}
\input{\topdir/client/fragments/cond_atomic_div}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_div(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_div}}
\label{api:c:group_atomic_div}
\index{group\_atomic\_div!C API}
\input{\topdir/client/fragments/group_atomic_div}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_div(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_mod}}
\label{api:c:atomic_mod}
\index{atomic\_mod!C API}
\input{\topdir/client/fragments/atomic_mod}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_mod(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_mod}}
\label{api:c:cond_atomic_mod}
\index{cond\_atomic\_mod!C API}
\input{\topdir/client/fragments/cond_atomic_mod}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_mod(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_mod}}
\label{api:c:group_atomic_mod}
\index{group\_atomic\_mod!C API}
\input{\topdir/client/fragments/group_atomic_mod}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_mod(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_and}}
\label{api:c:atomic_and}
\index{atomic\_and!C API}
\input{\topdir/client/fragments/atomic_and}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_and(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_and}}
\label{api:c:cond_atomic_and}
\index{cond\_atomic\_and!C API}
\input{\topdir/client/fragments/cond_atomic_and}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_and(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_and}}
\label{api:c:group_atomic_and}
\index{group\_atomic\_and!C API}
\input{\topdir/client/fragments/group_atomic_and}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_and(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_or}}
\label{api:c:atomic_or}
\index{atomic\_or!C API}
\input{\topdir/client/fragments/atomic_or}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_or(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_or}}
\label{api:c:cond_atomic_or}
\index{cond\_atomic\_or!C API}
\input{\topdir/client/fragments/cond_atomic_or}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_or(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_or}}
\label{api:c:group_atomic_or}
\index{group\_atomic\_or!C API}
\input{\topdir/client/fragments/group_atomic_or}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_or(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_xor}}
\label{api:c:atomic_xor}
\index{atomic\_xor!C API}
\input{\topdir/client/fragments/atomic_xor}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_xor(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_xor}}
\label{api:c:cond_atomic_xor}
\index{cond\_atomic\_xor!C API}
\input{\topdir/client/fragments/cond_atomic_xor}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_xor(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_xor}}
\label{api:c:group_atomic_xor}
\index{group\_atomic\_xor!C API}
\input{\topdir/client/fragments/group_atomic_xor}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_xor(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_min}}
\label{api:c:atomic_min}
\index{atomic\_min!C API}
\input{\topdir/client/fragments/atomic_min}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_min(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_min}}
\label{api:c:cond_atomic_min}
\index{cond\_atomic\_min!C API}
\input{\topdir/client/fragments/cond_atomic_min}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_min(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_min}}
\label{api:c:group_atomic_min}
\index{group\_atomic\_min!C API}
\input{\topdir/client/fragments/group_atomic_min}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_min(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{atomic\_max}}
\label{api:c:atomic_max}
\index{atomic\_max!C API}
\input{\topdir/client/fragments/atomic_max}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_atomic_max(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_atomic\_max}}
\label{api:c:cond_atomic_max}
\index{cond\_atomic\_max!C API}
\input{\topdir/client/fragments/cond_atomic_max}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_atomic_max(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_atomic\_max}}
\label{api:c:group_atomic_max}
\index{group\_atomic\_max!C API}
\input{\topdir/client/fragments/group_atomic_max}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_atomic_max(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{string\_prepend}}
\label{api:c:string_prepend}
\index{string\_prepend!C API}
\input{\topdir/client/fragments/string_prepend}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_string_prepend(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_string\_prepend}}
\label{api:c:cond_string_prepend}
\index{cond\_string\_prepend!C API}
\input{\topdir/client/fragments/cond_string_prepend}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_string_prepend(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_string\_prepend}}
\label{api:c:group_string_prepend}
\index{group\_string\_prepend!C API}
\input{\topdir/client/fragments/group_string_prepend}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_string_prepend(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{string\_append}}
\label{api:c:string_append}
\index{string\_append!C API}
\input{\topdir/client/fragments/string_append}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_string_append(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_string\_append}}
\label{api:c:cond_string_append}
\index{cond\_string\_append!C API}
\input{\topdir/client/fragments/cond_string_append}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_string_append(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_string\_append}}
\label{api:c:group_string_append}
\index{group\_string\_append!C API}
\input{\topdir/client/fragments/group_string_append}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_string_append(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% string_ltrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{string\_ltrim}}
\label{api:c:string_ltrim}
\index{string\_ltrim!C API}
\input{\topdir/client/fragments/string_ltrim}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_string_ltrim(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_string_ltrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_string\_ltrim}}
\label{api:c:cond_string_ltrim}
\index{cond\_string\_ltrim!C API}
\input{\topdir/client/fragments/cond_string_ltrim}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_string_ltrim(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_string_ltrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_string\_ltrim}}
\label{api:c:group_string_ltrim}
\index{group\_string\_ltrim!C API}
\input{\topdir/client/fragments/group_string_ltrim}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_string_ltrim(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% string_rtrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{string\_rtrim}}
\label{api:c:string_rtrim}
\index{string\_rtrim!C API}
\input{\topdir/client/fragments/string_rtrim}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_string_rtrim(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_string_rtrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_string\_rtrim}}
\label{api:c:cond_string_rtrim}
\index{cond\_string\_rtrim!C API}
\input{\topdir/client/fragments/cond_string_rtrim}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_string_rtrim(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_string_rtrim %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_string\_rtrim}}
\label{api:c:group_string_rtrim}
\index{group\_string\_rtrim!C API}
\input{\topdir/client/fragments/group_string_rtrim}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_string_rtrim(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% list_lpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{list\_lpush}}
\label{api:c:list_lpush}
\index{list\_lpush!C API}
\input{\topdir/client/fragments/list_lpush}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_list_lpush(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_list_lpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_list\_lpush}}
\label{api:c:cond_list_lpush}
\index{cond\_list\_lpush!C API}
\input{\topdir/client/fragments/cond_list_lpush}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_list_lpush(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_list_lpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_list\_lpush}}
\label{api:c:group_list_lpush}
\index{group\_list\_lpush!C API}
\input{\topdir/client/fragments/group_list_lpush}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_list_lpush(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% list_rpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{list\_rpush}}
\label{api:c:list_rpush}
\index{list\_rpush!C API}
\input{\topdir/client/fragments/list_rpush}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_list_rpush(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_list_rpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_list\_rpush}}
\label{api:c:cond_list_rpush}
\index{cond\_list\_rpush!C API}
\input{\topdir/client/fragments/cond_list_rpush}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_list_rpush(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_list_rpush %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_list\_rpush}}
\label{api:c:group_list_rpush}
\index{group\_list\_rpush!C API}
\input{\topdir/client/fragments/group_list_rpush}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_list_rpush(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% set_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{set\_add}}
\label{api:c:set_add}
\index{set\_add!C API}
\input{\topdir/client/fragments/set_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_set_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_set_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_set\_add}}
\label{api:c:cond_set_add}
\index{cond\_set\_add!C API}
\input{\topdir/client/fragments/cond_set_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_set_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_set_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_set\_add}}
\label{api:c:group_set_add}
\index{group\_set\_add!C API}
\input{\topdir/client/fragments/group_set_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_set_add(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% set_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{set\_remove}}
\label{api:c:set_remove}
\index{set\_remove!C API}
\input{\topdir/client/fragments/set_remove}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_set_remove(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_set_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_set\_remove}}
\label{api:c:cond_set_remove}
\index{cond\_set\_remove!C API}
\input{\topdir/client/fragments/cond_set_remove}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_set_remove(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_set_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_set\_remove}}
\label{api:c:group_set_remove}
\index{group\_set\_remove!C API}
\input{\topdir/client/fragments/group_set_remove}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_set_remove(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% set_intersect %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{set\_intersect}}
\label{api:c:set_intersect}
\index{set\_intersect!C API}
\input{\topdir/client/fragments/set_intersect}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_set_intersect(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_set_intersect %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_set\_intersect}}
\label{api:c:cond_set_intersect}
\index{cond\_set\_intersect!C API}
\input{\topdir/client/fragments/cond_set_intersect}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_set_intersect(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_set_intersect %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_set\_intersect}}
\label{api:c:group_set_intersect}
\index{group\_set\_intersect!C API}
\input{\topdir/client/fragments/group_set_intersect}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_set_intersect(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% set_union %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{set\_union}}
\label{api:c:set_union}
\index{set\_union!C API}
\input{\topdir/client/fragments/set_union}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_set_union(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_set_union %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_set\_union}}
\label{api:c:cond_set_union}
\index{cond\_set\_union!C API}
\input{\topdir/client/fragments/cond_set_union}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_set_union(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_set_union %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_set\_union}}
\label{api:c:group_set_union}
\index{group\_set\_union!C API}
\input{\topdir/client/fragments/group_set_union}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_set_union(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% document_rename %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{document\_rename}}
\label{api:c:document_rename}
\index{document\_rename!C API}
\input{\topdir/client/fragments/document_rename}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_document_rename(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_document_rename %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_document\_rename}}
\label{api:c:cond_document_rename}
\index{cond\_document\_rename!C API}
\input{\topdir/client/fragments/cond_document_rename}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_document_rename(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_document_rename %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_document\_rename}}
\label{api:c:group_document_rename}
\index{group\_document\_rename!C API}
\input{\topdir/client/fragments/group_document_rename}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_document_rename(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% document_unset %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{document\_unset}}
\label{api:c:document_unset}
\index{document\_unset!C API}
\input{\topdir/client/fragments/document_unset}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_document_unset(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_document_unset %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_document\_unset}}
\label{api:c:cond_document_unset}
\index{cond\_document\_unset!C API}
\input{\topdir/client/fragments/cond_document_unset}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_document_unset(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_document_unset %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_document\_unset}}
\label{api:c:group_document_unset}
\index{group\_document\_unset!C API}
\input{\topdir/client/fragments/group_document_unset}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_document_unset(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_add}}
\label{api:c:map_add}
\index{map\_add!C API}
\input{\topdir/client/fragments/map_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_add}}
\label{api:c:cond_map_add}
\index{cond\_map\_add!C API}
\input{\topdir/client/fragments/cond_map_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_add}}
\label{api:c:group_map_add}
\index{group\_map\_add!C API}
\input{\topdir/client/fragments/group_map_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_add(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_remove}}
\label{api:c:map_remove}
\index{map\_remove!C API}
\input{\topdir/client/fragments/map_remove}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_remove(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_remove}}
\label{api:c:cond_map_remove}
\index{cond\_map\_remove!C API}
\input{\topdir/client/fragments/cond_map_remove}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_remove(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_remove %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_remove}}
\label{api:c:group_map_remove}
\index{group\_map\_remove!C API}
\input{\topdir/client/fragments/group_map_remove}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_remove(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_attribute* attrs, size\_t attrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_attributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_add}}
\label{api:c:map_atomic_add}
\index{map\_atomic\_add!C API}
\input{\topdir/client/fragments/map_atomic_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_add}}
\label{api:c:cond_map_atomic_add}
\index{cond\_map\_atomic\_add!C API}
\input{\topdir/client/fragments/cond_map_atomic_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_add(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_add %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_add}}
\label{api:c:group_map_atomic_add}
\index{group\_map\_atomic\_add!C API}
\input{\topdir/client/fragments/group_map_atomic_add}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_add(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_sub}}
\label{api:c:map_atomic_sub}
\index{map\_atomic\_sub!C API}
\input{\topdir/client/fragments/map_atomic_sub}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_sub(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_sub}}
\label{api:c:cond_map_atomic_sub}
\index{cond\_map\_atomic\_sub!C API}
\input{\topdir/client/fragments/cond_map_atomic_sub}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_sub(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_sub %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_sub}}
\label{api:c:group_map_atomic_sub}
\index{group\_map\_atomic\_sub!C API}
\input{\topdir/client/fragments/group_map_atomic_sub}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_sub(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_mul}}
\label{api:c:map_atomic_mul}
\index{map\_atomic\_mul!C API}
\input{\topdir/client/fragments/map_atomic_mul}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_mul(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_mul}}
\label{api:c:cond_map_atomic_mul}
\index{cond\_map\_atomic\_mul!C API}
\input{\topdir/client/fragments/cond_map_atomic_mul}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_mul(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_mul %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_mul}}
\label{api:c:group_map_atomic_mul}
\index{group\_map\_atomic\_mul!C API}
\input{\topdir/client/fragments/group_map_atomic_mul}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_mul(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_div}}
\label{api:c:map_atomic_div}
\index{map\_atomic\_div!C API}
\input{\topdir/client/fragments/map_atomic_div}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_div(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_div}}
\label{api:c:cond_map_atomic_div}
\index{cond\_map\_atomic\_div!C API}
\input{\topdir/client/fragments/cond_map_atomic_div}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_div(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_div %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_div}}
\label{api:c:group_map_atomic_div}
\index{group\_map\_atomic\_div!C API}
\input{\topdir/client/fragments/group_map_atomic_div}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_div(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_mod}}
\label{api:c:map_atomic_mod}
\index{map\_atomic\_mod!C API}
\input{\topdir/client/fragments/map_atomic_mod}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_mod(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_mod}}
\label{api:c:cond_map_atomic_mod}
\index{cond\_map\_atomic\_mod!C API}
\input{\topdir/client/fragments/cond_map_atomic_mod}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_mod(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_mod %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_mod}}
\label{api:c:group_map_atomic_mod}
\index{group\_map\_atomic\_mod!C API}
\input{\topdir/client/fragments/group_map_atomic_mod}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_mod(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_and}}
\label{api:c:map_atomic_and}
\index{map\_atomic\_and!C API}
\input{\topdir/client/fragments/map_atomic_and}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_and(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_and}}
\label{api:c:cond_map_atomic_and}
\index{cond\_map\_atomic\_and!C API}
\input{\topdir/client/fragments/cond_map_atomic_and}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_and(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_and %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_and}}
\label{api:c:group_map_atomic_and}
\index{group\_map\_atomic\_and!C API}
\input{\topdir/client/fragments/group_map_atomic_and}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_and(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_or}}
\label{api:c:map_atomic_or}
\index{map\_atomic\_or!C API}
\input{\topdir/client/fragments/map_atomic_or}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_or(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_or}}
\label{api:c:cond_map_atomic_or}
\index{cond\_map\_atomic\_or!C API}
\input{\topdir/client/fragments/cond_map_atomic_or}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_or(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_or %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_or}}
\label{api:c:group_map_atomic_or}
\index{group\_map\_atomic\_or!C API}
\input{\topdir/client/fragments/group_map_atomic_or}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_or(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_xor}}
\label{api:c:map_atomic_xor}
\index{map\_atomic\_xor!C API}
\input{\topdir/client/fragments/map_atomic_xor}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_xor(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_xor}}
\label{api:c:cond_map_atomic_xor}
\index{cond\_map\_atomic\_xor!C API}
\input{\topdir/client/fragments/cond_map_atomic_xor}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_xor(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_xor %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_xor}}
\label{api:c:group_map_atomic_xor}
\index{group\_map\_atomic\_xor!C API}
\input{\topdir/client/fragments/group_map_atomic_xor}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_xor(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_string\_prepend}}
\label{api:c:map_string_prepend}
\index{map\_string\_prepend!C API}
\input{\topdir/client/fragments/map_string_prepend}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_string_prepend(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_string\_prepend}}
\label{api:c:cond_map_string_prepend}
\index{cond\_map\_string\_prepend!C API}
\input{\topdir/client/fragments/cond_map_string_prepend}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_string_prepend(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_string_prepend %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_string\_prepend}}
\label{api:c:group_map_string_prepend}
\index{group\_map\_string\_prepend!C API}
\input{\topdir/client/fragments/group_map_string_prepend}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_string_prepend(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_string\_append}}
\label{api:c:map_string_append}
\index{map\_string\_append!C API}
\input{\topdir/client/fragments/map_string_append}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_string_append(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_string\_append}}
\label{api:c:cond_map_string_append}
\index{cond\_map\_string\_append!C API}
\input{\topdir/client/fragments/cond_map_string_append}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_string_append(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_string_append %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_string\_append}}
\label{api:c:group_map_string_append}
\index{group\_map\_string\_append!C API}
\input{\topdir/client/fragments/group_map_string_append}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_string_append(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_min}}
\label{api:c:map_atomic_min}
\index{map\_atomic\_min!C API}
\input{\topdir/client/fragments/map_atomic_min}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_min(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_min}}
\label{api:c:cond_map_atomic_min}
\index{cond\_map\_atomic\_min!C API}
\input{\topdir/client/fragments/cond_map_atomic_min}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_min(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_min %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_min}}
\label{api:c:group_map_atomic_min}
\index{group\_map\_atomic\_min!C API}
\input{\topdir/client/fragments/group_map_atomic_min}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_min(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% map_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{map\_atomic\_max}}
\label{api:c:map_atomic_max}
\index{map\_atomic\_max!C API}
\input{\topdir/client/fragments/map_atomic_max}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_map_atomic_max(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% cond_map_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{cond\_map\_atomic\_max}}
\label{api:c:cond_map_atomic_max}
\index{cond\_map\_atomic\_max!C API}
\input{\topdir/client/fragments/cond_map_atomic_max}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_cond_map_atomic_max(struct hyperdex_client* client,
        const char* space,
        const char* key, size_t key_sz,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const char* key, size\_t key\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_key}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% group_map_atomic_max %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{group\_map\_atomic\_max}}
\label{api:c:group_map_atomic_max}
\index{group\_map\_atomic\_max!C API}
\input{\topdir/client/fragments/group_map_atomic_max}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_group_map_atomic_max(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\item \code{const struct hyperdex\_client\_map\_attribute* mapattrs, size\_t mapattrs\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_mapattributes}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% search %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{search}}
\label{api:c:search}
\index{search!C API}
\input{\topdir/client/fragments/search}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_search(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        enum hyperdex_client_returncode* status,
        const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_iterator_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_iterator_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_iterator_predicates}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_iterator_status}
\item \code{const struct hyperdex\_client\_attribute** attrs, size\_t* attrs\_sz}\\
\input{\topdir/c/client/fragments/out_iterator_attributes}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% sorted_search %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{sorted\_search}}
\label{api:c:sorted_search}
\index{sorted\_search!C API}
\input{\topdir/client/fragments/sorted_search}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_sorted_search(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        const char* sort_by,
        uint64_t limit,
        int maxmin,
        enum hyperdex_client_returncode* status,
        const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_iterator_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_iterator_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_iterator_predicates}
\item \code{const char* sort\_by}\\
\input{\topdir/c/client/fragments/in_iterator_sortby}
\item \code{uint64\_t limit}\\
\input{\topdir/c/client/fragments/in_iterator_limit}
\item \code{int maxmin}\\
\input{\topdir/c/client/fragments/in_iterator_maxmin}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_iterator_status}
\item \code{const struct hyperdex\_client\_attribute** attrs, size\_t* attrs\_sz}\\
\input{\topdir/c/client/fragments/out_iterator_attributes}
\end{itemize}

%%%%%%%%%%%%%%%%%%%% count %%%%%%%%%%%%%%%%%%%%
\pagebreak
\subsection{\code{count}}
\label{api:c:count}
\index{count!C API}
\input{\topdir/client/fragments/count}

\paragraph{Definition:}
\begin{ccode}
int64_t hyperdex_client_count(struct hyperdex_client* client,
        const char* space,
        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
        enum hyperdex_client_returncode* status,
        uint64_t* count);
\end{ccode}

\paragraph{Parameters:}
\begin{itemize}[noitemsep]
\item \code{struct hyperdex\_client* client}\\
\input{\topdir/c/client/fragments/in_asynccall_structclient}
\item \code{const char* space}\\
\input{\topdir/c/client/fragments/in_asynccall_spacename}
\item \code{const struct hyperdex\_client\_attribute\_check* checks, size\_t checks\_sz}\\
\input{\topdir/c/client/fragments/in_asynccall_predicates}
\end{itemize}

\paragraph{Returns:}
\begin{itemize}[noitemsep]
\item \code{enum hyperdex\_client\_returncode* status}\\
\input{\topdir/c/client/fragments/out_asynccall_status}
\item \code{uint64\_t* count}\\
\input{\topdir/c/client/fragments/out_asynccall_count}
\end{itemize}
